package com.durian.base.utils;

import android.text.TextUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.regex.Pattern;

/**
 * 说明：NumberUtils
 * <p/>
 * 作者：fanly
 * <p/>
 * 类型：Class
 * <p/>
 * 时间：2019-06-17 14:12
 * <p/>
 * 版本：version 1.0
 */
public class NumberUtils {
    /**
     * 说明：禁止实例化
     */
    private NumberUtils() {
    }

    private final static DecimalFormat decimalFormat = new DecimalFormat();

    private static DecimalFormat getDecimalFormat() {
        return decimalFormat;
    }

    /**
     * 判断是否为整数
     *
     * @param str
     * @return 是整数返回true, 否则返回false
     */
    public static boolean isInteger(String str) {
        boolean result = false;
        if (StringUtils.isNotEmpty(str)) {
            Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
            result = pattern.matcher(str).matches();
        }

        return result;
    }

    /**
     * 说明：String转Int
     *
     * @param str 目标String
     * @return int 转换失败返回-1
     */
    public final static int toInt(String str) {
        return toInt(str, -1);
    }

    /**
     * 说明：String转Int
     *
     * @param str 目标String
     * @param def 默认值
     * @return int
     */
    public final static int toInt(String str, int def) {
        int num = def;
        try {
            if (!StringUtils.isEmpty(str)) {
                num = Integer.parseInt(str);
            }
        } catch (NumberFormatException e) {
            LogUtils.e(str + " : 转 Interger 失败！");
        }
        return num;
    }

    /**
     * 说明：String转Double
     *
     * @param str 目标String
     * @return
     */
    public final static double toDouble(String str) {
        return toDouble(str, 0.0d);
    }

    /**
     * 说明：String转Double
     *
     * @param str 目标String
     * @param def 默认值
     * @return
     */
    public final static double toDouble(String str, double def) {
        double num = def;
        try {
            if (!StringUtils.isEmpty(str)) {
                num = Double.parseDouble(str);
            }
        } catch (NumberFormatException e) {
            LogUtils.e(str + " : 转 Double 失败！");
        }
        return num;
    }

    /**
     * 说明：String转long
     *
     * @param str
     * @return 转换异常返回 -1
     */
    public static long toLong(String str) {
        return toLong(str, -1L);
    }

    /**
     * 说明：String转long
     *
     * @param str 目标String
     * @param def 默认值
     * @return
     */
    public static long toLong(String str, long def) {
        long num = def;
        try {
            if (!StringUtils.isEmpty(str)) {
                num = Long.parseLong(str);
            }
        } catch (NumberFormatException e) {
            LogUtils.e(str + " : 转 Double 失败！");
        }
        return num;
    }

    /**
     * 说明：相除
     *
     * @param d1
     * @param d2
     * @return
     */
    public final static double divide(double d1, double d2) {
        if (d2 == 0) {
            return 0;
        } else {
            BigDecimal b1 = new BigDecimal(d1);
            BigDecimal b2 = new BigDecimal(d2);
            return b1.divide(b2, BigDecimal.ROUND_DOWN).doubleValue();
        }
    }

    /**
     * 说明：相除
     *
     * @param d1
     * @param d2
     * @return
     */
    public final static double divide(double d1, double d2, RoundingMode roundingMode) {
        if (d2 == 0) {
            return 0;
        } else {
            BigDecimal b1 = new BigDecimal(d1);
            BigDecimal b2 = new BigDecimal(d2);
            return b1.divide(b2, roundingMode).doubleValue();
        }
    }

    /**
     * 相乘
     *
     * @param doubles
     * @return
     */
    public final static double multipy(double... doubles) {
        BigDecimal result = new BigDecimal("1");
        if (doubles != null && doubles.length > 0) {
            for (int i = 0; i < doubles.length; i++) {
                result = result.multiply(new BigDecimal(String.valueOf(doubles[i])));
            }
        }
        return result.doubleValue();
    }

    /**
     * 说明：字符串转布尔
     *
     * @param str 目标String
     * @return
     */
    public static boolean toBool(String str) {
        return Boolean.parseBoolean(str);
    }

    /**
     * 说明：保留N位小数
     *
     * @param d
     * @param n
     * @return
     */
    public final static String saveDecimal(double d, int n) {
        StringBuilder sb = new StringBuilder("#0");
        if (n >= 1) {
            sb.append(".");
            for (int i = 0; i < n; i++) {
                sb.append("0");
            }
        }
        DecimalFormat formatter = new DecimalFormat();
        formatter.applyPattern(sb.toString());
        return formatter.format(d);
    }

    /**
     * 说明：减法
     *
     * @param str1-str2
     * @return 返回double
     */
    public final static double subDouble(String str1, String str2) {
        BigDecimal result = new BigDecimal("0");
        if (StringUtils.isNotEmpty(str1)) {
            result = result.add(new BigDecimal(String.valueOf(toDouble(str1))));
        }
        if (StringUtils.isNotEmpty(str2)) {
            result = result.subtract(new BigDecimal(String.valueOf(toDouble(str2))));
        }
        return result.doubleValue();
    }

    /**
     * 说明：累加方法
     *
     * @param str
     * @return 返回double
     */
    public final static double addDouble(String... str) {
        BigDecimal result = new BigDecimal("0");
        if (str != null && str.length > 0) {
            for (int i = 0; i < str.length; i++) {
                result = result.add(new BigDecimal(String.valueOf(toDouble(str[i]))));
            }
        }
        return result.doubleValue();
    }

    /**
     * 说明：累加方法
     *
     * @param doubles
     * @return 返回double
     */
    public final static double addDouble(double... doubles) {
        BigDecimal result = new BigDecimal("0");
        if (doubles != null && doubles.length > 0) {
            for (int i = 0; i < doubles.length; i++) {
                result = result.add(new BigDecimal(String.valueOf(doubles[i])));
            }
        }
        return result.doubleValue();
    }

    /**
     * 说明：累加方法
     *
     * @param str
     * @return 返回int
     */
    public final static int addInt(String... str) {
        int total = 0;
        for (String s : str) {
            total += toInt(s);
        }
        return total;
    }

    /**
     * 说明：二进制转十进制
     *
     * @param str 为只包含0，1的32位字符串，并且以0开头
     * @return 转换失败返回-1
     */
    public static String binToDec(String str) {
        if (StringUtils.isEmpty(str)) {
            return "";
        } else if (str.length() < 32 || (str.length() == 32 && str.startsWith("0"))) {
            if (str.matches("[0-1;]+")) {
                return Integer.valueOf(str, 2).toString();
            } else {
                LogUtils.e(str + "二进制转十进制出错：字符串不是二进制！！！");
                return "-1";
            }
        } else {
            LogUtils.e(str + "二进制转十进制出错：长度超出32位！！！");
            return "-1";
        }
    }

    /**
     * 说明：十进制转二进制
     *
     * @param str
     * @return
     */
    public static String decToBin(String str) {
        if (StringUtils.isEmpty(str)) {
            return "";
        }
        return Integer.toBinaryString(toInt(str));
    }

    /**
     * 说明：二进制转十六进制
     *
     * @param str
     * @return 转换失败返回-1
     */
    public static String binToHex(String str) {
        if (StringUtils.isEmpty(str)) {
            return "";
        }
        if (str.matches("[0-1;]+")) {
            String dec = binToDec(str);
            return Integer.toHexString(Integer.parseInt(dec));
        } else {
            LogUtils.e(str + "二进制转十六进制：字符串不是二进制！！！");
            return "-1";
        }
    }

    /**
     * 说明：十六进制转二进制
     *
     * @param str
     * @return 转换失败返回""
     */
    public static String hexToBin(String str) {
        String result = "";
        if (!StringUtils.isEmpty(str)) {
            try {
                result = decToBin(Integer.valueOf(str, 16).toString());
            } catch (NumberFormatException e) {
                LogUtils.e(str + "十六进制转二进制异常！！！");
            }
        }
        return result;
    }

    /**
     * 说明：十进制转十六进制
     *
     * @param str
     * @return
     */
    public static String decToHex(String str) {
        if (StringUtils.isEmpty(str)) {
            return "";
        }
        return Integer.toHexString(toInt(str));
    }

    /**
     * 说明：十六进制转十进制
     *
     * @param str
     * @return 转换失败返回""
     */
    public static String hexToDec(String str) {
        String result = "";
        if (!StringUtils.isEmpty(str)) {
            try {
                result = Integer.valueOf(str, 16).toString();
            } catch (NumberFormatException e) {
                LogUtils.e(str + "十六进制转十进制异常！！！");
            }
        }
        return result;
    }

    /**
     * double转string
     *
     * @param d
     * @return
     */
    public static String toString(double d) {
        Double dou_obj = Double.valueOf(d);
        NumberFormat nf = NumberFormat.getInstance();
        nf.setGroupingUsed(false);
        return nf.format(dou_obj);
    }

    /**
     * 转行成两位小数
     * 5.2.0
     *
     * @param str
     * @return
     */
    public static String toFloatString(String str) {
        if (TextUtils.isEmpty(str))
            return "0.00";
        else {
            Double d = Double.valueOf(str);
            NumberFormat nf = NumberFormat.getNumberInstance();
            nf.setMaximumFractionDigits(2);
            nf.setMinimumFractionDigits(2);
            return nf.format(d);
        }
    }

    /**
     * 如果数字超过万，改为以万为单位的数字
     *
     * @return
     */
    public static String numTransformationFirst(String num) {
        if (TextUtils.isEmpty(num)) {
            return "0.00";
        } else if (num.contains(".")) {
            String integerPart = num.split("\\.")[0];
            return numTransformationSecond(integerPart,num);
        } else {
            return numTransformationSecond(num,num);
        }
    }

    /**
     * 转化万方法第二步
     * 5.2.0
     * @param integerPart
     * @return
     */
    public static String numTransformationSecond(String integerPart,String num) {
        if (integerPart.length() > 4) {
            BigDecimal bigDecimal = new BigDecimal(integerPart);
            // 转换为万元（除以10000）
            BigDecimal decimal = bigDecimal.divide(new BigDecimal("10000"));
            // 保留两位小数
            DecimalFormat formater = new DecimalFormat("0.00");
            // 四舍五入
            formater.setRoundingMode(RoundingMode.HALF_UP);
            // 格式化完成之后得出结果
            String formatNum = formater.format(decimal)+"万";
            return formatNum;
        } else {
            return Number.value(num).retainDecimal(2).value();
        }
    }
}
